R and Rstudio

First, you will need to install R on https://cran.r-project.org/. Choose the fitted version for your computer system.

R software view.

Then you will need an Integrated Development Environment (IDE) which allows you to have a more comprehensive overview and easier access to packages and other online features from R. The most commonly used IDE for R is Rstudio. You can download it via https://rstudio.com/products/rstudio/download/#download, and select the free version for your exploitation system.

RStudio IDE view.

R Packages

If basic R already handles many data, the true power of this language is to have more than 10 000 additional updated packages freely available online. Most of them can be directly downloaded on the CRAN website while others will be accessible only via their GitHub deposit.

To download the package you have several different solutions:

1. The easiest way is using the Package windows of Rstudio and directly downloading it from the CRAN deposit.
2. You can also use the following code to download it install.packages("").
3. If the package is not available on the CRAN deposit you can directly download it from the GitHub site. You will need first to download the “remote” package to access online content. Then you can type the URL of the link to your package.

install.packages("remotes") #install "remotes" package.
devtools::install_github("philipp-baumann/simplerspec", force = FALSE) # The "force" parameter (TRUE or FALSE) depending if you want to overwrite your previous download of the package

4. Last but not least, you can manually download the .zip or .tar.gz of the package online and unpacked it via the package windows of Rstudio or directly to your R folder (@ref(REnvironment))

Once you download the package you have to load it to your environment. You can do it with the line library() , you will have to do it every time you start a new session in R.

RStudio Package window view.

Basic commands

You can open a new R window to start typing some code lines.

R is based on statistical treatment so numbers and operations are one of the most important components of this language. You can type basic operations to get familiar with the syntax:

> 2+3
[1] 5 
> 2*3
[1] 6
> 2^3
[1] 8

Special operators can also be used.

> pi
[1] 3.141593 
> sqrt(2)
[1] 1.414214

For letters and other characters you can use the print()command. It does work for special operators but not if several are used at the same time.

> print("Hello World")
[1] "Hello world" 
> print(pi)
[1] 1.414214
> print("The zero occurs at", 2 * pi, "radians.")
Error in print.default("The zero occurs at", 2 * pi, "radians."):
invalid 'quote' argument

To be able to use both numeric or special operators and characters, use the cat() command. You need to end it with the "\n" code.

> cat("The zero occurs at", 2 * pi, "radians.", "\n")
The zero occurs at 6.283185 radians.

R basic commands.

An important topic is the help() command (in Rstudio ? can also work). This function will give access to the description of the command you are typing inside the strings. With an internet connection on Rstudio the ?? line will give you information on your command even if it is coming from a non-downloaded package.

R help window after typing the help(c) command.

Another important source that will help you understand the functions is Cheetsheets. It is easy to search for different Cheetsheets on the Internet.

Cheetsheets

Setting variables

Analyzing data is important but if we can not store them we won’t be able to go very far. You can store any variable with the <- or = code. The most important variables are numbers and character strings.

> x <- pi
> y = 2*2
> print(x*y)
[1] 12.56637

Numerical values

On the upper code line, it is a number variable storage (Numeric values).

> a <- "The zero occurs at"
> b = "radians."
> cat(a, 2 * x, b, "\n")
The zero occurs at 6.283185 radians.

Character values

On the upper code line, it is two character string variables storage (Character values) combined with a number variable.

We can also give a vector several numbers (Vector of numbers) or several characters (Vector of character strings) with the code line c().

> a <- c("Red", "Blue", "Green", "Black", "White") 
> b <-  c(5, 6, 6, 8, 11)
> print(a)
[1] "Red"   "Blue"  "Green" "Black" "White"
> b
[1]  5  6  6  8 11

Useful commands

You have to distinguish the class of data from its mode. The class can be seen as the structure of the data while the mode is just the “type” of data. In simple vectors there is no difference but on more complex objects you will have a specific class for the all structure (matrices, arrays…) while the data stored inside will be related to one or several mode (numeric, character, logical…) To know the class of your variable you can use the class()command and to know the mode (type of info stored) the mode(). The str() function will give you more information about the data and its class.

> str(a)
[1] chr [1:5] "Red" "Blue" "Green" "Black" "White"
> class(b)
[1] "numeric"
> mode(print)
[1] "function"

Two other important commands are ls() which gives you your number of saved variable and rm() which remove one variable. ls.str() is a transformed way to see the content of each variable and not only there name. You can remove all your variable by making rm(list = ls()). The c(1:10) used here gives a vector list of ten numbers from 1 to 10. The : function create a sequence of numbers.

> y <- 3
> y <- "Red"
> z <- c(1:10)
> ls()
[1] "x" "y" "z"
> ls.str()
x :  num 3
y :  chr "RED"
z :  int [1:10] 1 2 3 4 5 6 7 8 9 10
> rm(list = ls())
> ls()
character(0)

To generate a more “complex” sequence you can use the seq(x, y, n) function where x is the starting number, y is the ending number and n is the interval. If you want to create a sequence with a specific number of intervals you can use the length.out = argument before n.

> seq(2, 50, 4)
 [1]  2  6 10 14 18 22 26 30 34 38 42 46 50
> seq(2, 50, length.out = 4)
[1]  2 18 34 50

Matrices and Arrays

You can combine vectors together in order to create matrices the first time. There are different ways of combining them. When can combine the different vector numbers with c() and then give a specific dimension x,y to the combined vector with dim(x,y) command. Or we can directly combine the two vectors as different columns from one matrix with cbind(col1, col2) or if you prefer combine via the rows with rbind(row1, row2). Another possible way is with matrix(data, nrow = n, ncol = n).

> b <- c(5, 6, 6, 8, 11)
> d <- c(12, 3, 4, 5, 6)
> matrix <- c(b,d)
> matrix
[1]  5  6  6  8 11 12  3  4  5  6
> dim(matrix) <- c(2,5) # first the rows number then the columns number
> print (matrix)
     [,1] [,2] [,3] [,4] [,5]
[1,]    5    6   11    3    5
[2,]    6    8   12    4    6

> matrix <- cbind(b, d)
> print(matrix)
      b  d
[1,]  5 12
[2,]  6  3
[3,]  6  4
[4,]  8  5
[5,] 11  6
> dim(matrix)
[1] 5 2

> matrix <- rbind(b, d)
> print(matrix)
     [,1] [,2] [,3] [,4] [,5]
[1,]    5    6   11    3    5
[2,]    6    8   12    4    6
> dim(matrix)
[1] 2 5
> class(matrix)
[1] "matrix" "array" 

The type array is a multidimensional n vectors. We will prefer data frame format or list format for combining different types of data. However, if you want more precision on array data you can look into @long_r_2019 pp.131 - 132 or @r_core_team_introduction_2022.

Factor values

Another type of important data is the factor class. They are defined as a vector of enumerated values. There is two type of factor the Grouping and the Categorical variables which are commonly used for ANOVA testing. The specificity of the factor is that they contain several levels (one for each type of factor). You can access the levels with levels()to see their names or nlevels()to see the number of levels.

> x <- factor(c("TRUE","FALSE","TRUE","TRUE","FALSE","NO DATA","TRUE", "FALSE"))
> class(x)
[1] "factor"
> levels(x)
[1] "FALSE"   "NO DATA" "TRUE" 
> a <- c("Red", "Blue", "Green", "Black", "White")
> y <- as.factor(a)
> nlevels(y)
[1] 5               #one for each type of character

You can also order factors by adding the ordered = TRUE code inside the factor() function. This can be useful when sorting the data you are dealing.

> x <- factor(c("TRUE","FALSE","TRUE","TRUE","FALSE","NO DATA","TRUE", "FALSE"))
> sorted <- factor(x, ordered = TRUE, levels = c("NO DATA", "FALSE",  "TRUE"))
> sorted
[1] TRUE    FALSE   TRUE    TRUE    FALSE   NO DATA TRUE    FALSE
Levels: NO DATA < FALSE < TRUE 

Lists and data frames

Two very common data types we will see here are List and Data Frame. A list can be seen as a collection of objects. They can be from different modes and sizes without any restrictions except for having different names. The data frame (more broadly used in Data Science) can be seen as a specific type of list with two conditions :

• All elements of a data frame are vectors.
• All elements of a data frame have an equal length.

Dataframe

For a list, you can type the list() code. The detail code is list(name_1 = object_1, …, name_m = object_m). The data frame looks similar to the list() function. You can write it down with the data.frame() code line. If you try to create a data frame with an unequal number between vectors it will notice it.

> Lst <- list(name="Fred", wife="Mary", no.children=3,
child.ages=c(4,7,9))
> str(Lst)
List of 4
 $ name       : chr "Fred"
 $ wife       : chr "Mary"
 $ no.children: num 3
 $ child.ages : num [1:3] 4 7 9
>
> df <- data.frame(id=1:3, name=c("Moe", "Larry", "Curly"), age=c(1:3))
>str(df)
'data.frame':   3 obs. of  3 variables:
 $ id  : int  1 2 3
 $ name: chr  "Moe" "Larry" "Curly"
 $ age : int  1 2 3
>
> df <- data.frame(id=1:3, name=c("Moe", "Larry", "Curly"), age=c(1,2))
Error in data.frame(id = 1:3, name = c("Moe", "Larry", "Curly"), age = c(1,  :
    arguments imply differing number of rows: 3, 2

This example is from the @r_core_team_introduction_2022 book.

Logical and Integer values

You have also logical values that can be “TRUE”, “FALSE” or “NULL”. You create them with a vector command and then T, F or N without strings c(T,F,F,N). There are useful values for logical comparison between two variables (See vector operator).

Integer values can also be created by adding the as.integer code on a numerical vector. By default numerical values are non integers in R.

> x <- c(T,F,T,F,T,N)
> class(x)
[1] "logical"
> y <- 2000 > 2022
> class(y)
[1] "logical"

> b <- c(5, 6, 6, 8, 11)
> b_int <- as.integer(b)   #Integer will truncated toward zero non integral number and imaginary part of complex numbers will be discarded.
> class(b_int)
[1] "integer"

Project

When you are opening a new project create a new project in the tab File and then create an R script in new file in the tab File. Choose carefully your project folder because it will be more complicated to move it later on.

R project folder structure.

You have several ways of controlling your folder location with getwd() and setting a new one with setwd(). The formula ./ will automatically call the project folder. Note that when your a calling any path into R you will need / and not \ as commonly used in windows or other programming languages (Cf. Latex)

Saving data

For saving your working space you have two ways:

• Either export one by one your file to specific formats (.csv, .jpg, .shp….) as we will see later.
• Saving via a .RData the file is more easily readable on R. You can save only one or multiple elements save(list = c("x","y"), file = "output.RData") or all environment of your project save.image(file = "output.RData").

Exercices

1. Calculate the following equation with R and copy the code lines:

\[ x = (2*4-4)^2 + \sqrt(9) \]

2. Solve the following equation rounded at 3 digits (if necessary) by using the quadratic formula: \[ -5x^2 - 6x + 11 = 2 \] For reminder the quadratic formula : \[ ax^2 + bx + c = 0 \]

\[ x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} \]

3. Create 5 vectors (minimum length 3) from different classes. Name them after their class name and export them as a list in a .RData file named Exercise_R_01

4. Give the objects class, variable mode and number, and observation number of the data rocks, trees and iris. These data are included in R basic package and you can call them any stored variable.